//

import React, {Component} from 'react';
import {Form, Input, Select, Icon, Menu, Dropdown, Popconfirm} from 'antd';
import style from './LabTableConfig.less';
import config from "../../config";
const Option = Select.Option;
const FormItem = Form.Item;

const commonRemark = '备注：CC—持续校准（标线带点检查）；MB—方法空白； LD—实验室平行样；RM—实验室内控样；BS—空白加标；MS-基体加标/样品加标；'
const commonEmptySample = ['MB', 'LD', 'RM', 'CC1', 'CC2', 'BS', 'MS'];

const hideUl = (name, visible) => {
  let dropDown = document.getElementById(name);
  if (visible) {
    dropDown.style.display = 'block';
  }
  else
    dropDown.style.display = 'none';
};

const getUnitCodeStr = (unitCode) => {
  let unitCodeStr = '';
  switch (unitCode) {
    case 1:
      unitCodeStr = 'mL';
      break;
    case 2:
      unitCodeStr = 'g';
      break;
    case 3:
      unitCodeStr = 'L';
      break;
    case 5:
      unitCodeStr = 'μg/mL';
      break;
    case 6:
      unitCodeStr = 'μg/L';
      break;
    case 7:
      unitCodeStr = 'ng/mL';
      break;
    case 8:
      unitCodeStr = 'ng/L';
      break;
    case 9:
      unitCodeStr = 'mg/L';
      break;
    case 10:
      unitCodeStr = 'mg/Kg';
      break;
    case 11:
      unitCodeStr = 'μg/Kg';
      break;
    case 12:
      unitCodeStr = 'mg/m³';
      break;
    case 13:
      unitCodeStr = 'μg/m³';
      break;
    case 14:
      unitCodeStr = '%';
      break;
    case 16:
      unitCodeStr = '无量纲';
      break;
    case 17:
      unitCodeStr = 'μs/cm';
      break;
    case 18:
      unitCodeStr = 'ms/s';
      break;
    case 19:
      unitCodeStr = 'g/Kg';
      break;
    case 20:
      unitCodeStr = 'MPN/L';
      break;
    case 21:
      unitCodeStr = '个/mL';
      break;
    case 22:
      unitCodeStr = 'MPN/100mL';
      break;
    case 23:
      unitCodeStr = '个/g';
      break;
    case 24:
      unitCodeStr = 'CFU/mL';
      break;
    case 25:
      unitCodeStr = 'L/(kg.min)';
      break;
    case 26:
      unitCodeStr = 'L/(kg.h)';
      break;
    case 27:
      unitCodeStr = '℃';
      break;
    case 28:
      unitCodeStr = 's';
      break;
    case 29:
      unitCodeStr = 'min';
      break;
    case 41:
      unitCodeStr = 'NTU';
      break;
    case 42:
      unitCodeStr = '度';
      break;
    case 43:
      unitCodeStr = '倍';
      break;
  }
  ;
  return unitCodeStr
};

const checkNoHeader = (params) => ({
  type: 'text',
  label: '检测编号',
  paramName: 'checkNo',
  initialValue: params.data.checkNo,
  rules: [config.reg.required]
});
const checkMethodHeader = (params) => ({
  type: 'text',
  label: '检测方法',
  paramName: 'checkMethodName',
  initialValue: params.data.checkMethodName,
  rules: [config.reg.required]
});
const checkItemHeader = (params) => ({
  type: 'text',
  label: '检测指标',
  paramName: 'checkItemName',
  initialValue: params.data.checkItemName,
  rules: [config.reg.required]
});
const applianceInfoHeader = (params) => ({
  type: 'textLabel',
  label: '仪器信息',
  paramName: 'applianceInfo',
  initialValue: params.data.applianceInfo,
  onClick: params.onApplianceClick,
  rules: [config.reg.required]
});
const mdlHeader = (params) => ({
  type: 'input',
  label: '方法检出限',
  paramName: 'mdl',
  initialValue: params.data.mdlNumber + params.data.mdlUnit,
  rules: [config.reg.required]
});
const instrumentHeader = (params) => ({
  type: 'input',
  label: '仪器条件',
  paramName: 'instrument',
  initialValue: params.data.instrument,
  rules: [config.reg.required]
});
const pretreatmentMethodsHeader = (params) => ({
  type: 'input',
  label: '样品前处理方法',
  paramName: 'pretreatmentMethods',
  initialValue: params.data.pretreatmentMethods,
  rules: [config.reg.required]
});
const designFormulasHeader = (params, formulaName = 'designFormulas') => ({
  type: 'input',
  label: '计算公式',
  paramName: formulaName,
  initialValue: params.data[formulaName],
  rules: [config.reg.required]
});

const numColumn = (params) => ({
  title: '序号',
  dataIndex: 'num',
  key: 'num',
  render: (text, record, index) => {
    if (record.isQualitySample)
      return <div style={{position: 'relative', width: '100%'}}>
        <Popconfirm
          title={'删除当前质控样？'}
          okText="确认"
          cancelText="取消"
          onConfirm={() => params.onDeleteQualitySample(index)}>
          <Icon type="close-circle"
                style={{fontSize: 12, color: '#B0B8C2', cursor: 'pointer', position: 'absolute', top: -15, left: -10}}/>
        </Popconfirm>

        <span>{text}</span>
      </div>
    return <span>{text}</span>
  }
});
const sampleColumn = (params) => ({
  title: '样品编号',
  dataIndex: 'sampleNo',
  key: 'sampleNo',
  width: 200,
  render: (text, record, index) => {
    if (record.sampleNoEdit) {
      if (params && params.data.readOnly)
        return (<span>{text}</span>);
      return (
        <FormItem key={record.key}>
          {
            params.getFieldDecorator('sampleNo_' + index, {
              initialValue: text,
              rules: [config.reg.required]
            })(
              <Input readOnly={params.readOnly}
                     onBlur={(e) => params.onChange(record.sampleNo, 'sampleNo', e.target.value)}/>
            )
          }
        </FormItem>);
    }
    return <span>{text}</span>
  }
});
const remarkColumn = (params, remarkName = 'remark') => ({
  title: '备注',
  dataIndex: remarkName,
  key: remarkName,
  render: (text, record) => {
    if (params && params.data.readOnly)
      return (<span>{text}</span>);
    return (
      <FormItem key={record.key}>
        {
          params.getFieldDecorator(remarkName + '_' + record.sampleNo, {
            initialValue: text,
            rules: [config.reg.required]
          })(
            <Input onBlur={(e) => params.onChange(record.sampleNo, remarkName, e.target.value)}/>
          )
        }
      </FormItem>
    );
  }
});

export default {


  //根据表单ID获取前端对应表单方法名/保存时请求的地址
  getRecordNameAndUrl: (recordId) => {
    let recordName = '';
    let requestMark = '';
    switch (recordId) {
      case 1001:
        recordName = 'jskdAnalysis';
        requestMark = 'applianceAnalyze';
        break;
      case 1002:
        recordName = 'instrumentAnalysis2';
        requestMark = 'applianceAnalyzeSecond';
        break;
      case 1003:
        recordName = 'instrumentAnalysis3';
        requestMark = 'applianceAnalyzeThird';
        break;
      case 1004:
        recordName = 'bodAnalysis';
        requestMark = 'bodAnalyze';
        break;
      case 1005:
        recordName = 'calorificAnalysis';
        requestMark = 'calorificValueAnalyze';
        break;
      case 1006:
        recordName = 'capacityAnalysis';
        requestMark = 'capacityAnalyze';
        break;
      case 1007:
        recordName = 'insectRecord';
        requestMark = 'doubleInsectAnalyze';
        break;
      case 1008:
        recordName = 'occupationalHealth';
        requestMark = 'dustWeighing';
        break;
      case 1009:
        recordName = 'radiationMeasurement';
        requestMark = 'emissivityMensurate';
        break;
      case 1010:
        recordName = 'communityEnvironment';
        requestMark = '';
        break;
      case 1011:
        recordName = 'lonSelective';
        requestMark = 'ionSelectiveElectrode';
        break;
      case 1012:
        recordName = 'microbiologicalAnalysis';
        requestMark = 'microbeAnalyze';
        break;
      case 1013:
        recordName = 'pHAnalysis';
        requestMark = 'phAndConductivityAnalyze';
        break;
      case 1014:
        recordName = 'sensoryAnalysis1';
        requestMark = 'senseAnalyzeOne';
        break;
      case 1015:
        recordName = 'sensoryAnalysis2';
        requestMark = 'senseAnalyzeTwo';
        break;
      case 1016:
        recordName = 'solidRecord1';
        requestMark = 'wasteWaterAnalyzeOne';
        break;
      case 1017:
        recordName = 'solidRecord2';
        requestMark = 'wasteWaterAnalyzeTwo';
        break;
      case 1018:
        recordName = 'weightAnalysis';
        requestMark = 'weightAnalyze';
        break;
      case 1019:
        recordName = 'pollutionSources';
        requestMark = '';
        break;
    }
    return {
      recordName,
      requestMark
    };
  },

  /***
   * BOD分析原始记录，
   * 需要传的参数  params={getFieldDecorator}
   * *****/
  bodAnalysis: (params) => {
    return {
      title: '五日生化需氧量分析原始记录',
      outRequestParam: ['checkMethodName', 'mdl', 'instrument', 'pretreatmentMethods',
        'checkMethodId', 'designFormulas', 'solutionInfo'],
      header: [
        checkNoHeader(params),
        checkMethodHeader(params),
        {
          type: 'text',
          label: '标准溶液信息',
          initialValue: params.data.solutionInfo,
          paramName: 'solutionInfo',
          rules: [config.reg.required]
        },
        mdlHeader(params),
        applianceInfoHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
        designFormulasHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '稀释倍数',
          dataIndex: 'dilutionRatio',
          key: 'dilutionRatio',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '培养前',
          key: 'previous',
          children: [
            {
              title: '用量(mL)',
              dataIndex: 'previousDosage',
              key: 'previousDosage',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('previousDosage_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'previousDosage', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            }, {
              title: 'DO(mg/L)',
              dataIndex: 'previousDo',
              key: 'previousDo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('previousDo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'previousDo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            }
          ]
        },
        {
          title: '培养后',
          key: 'after',
          children: [
            {
              title: '用量(mL)',
              dataIndex: 'afterDosage',
              key: 'afterDosage',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('afterDosage_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'afterDosage', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            }, {
              title: 'DO(mg/L)',
              dataIndex: 'afterDo',
              key: 'afterDo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('afterDo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'afterDo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            }
          ]
        },
        {
          title: '样品浓度(mg/L)',
          dataIndex: 'sampleConcentration',
          key: 'sampleConcentration',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input readOnly/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /***
   * JSKD-4-JJA1仪器分析原始记录
   * 需要传的参数  params={
   *                      getFieldDecorator,
   *                      samplingAmount,//取样量单位
   *                      samplingConcentration,//进样浓度单位
   *                      sampleConcentration //样品浓度单位
   *                      }
   * 传给父组件的参数:  this.props.Unit(name,value); //父组件获得更改单位
   * ****/
  jskdAnalysis: (params) => {
    return {
      title: '仪器分析原始记录',
      outRequestParam: ['checkItemId', 'checkMethodId', 'checkMethodName', 'solutionInfo', 'mdl', 'checkItemName',
        'instrument', 'pretreatmentMethods', 'curveFileNo', 'designFormulas'],
      unitCode: {sampleVolumeCode: 3, samplingConcentrationCode: 5, sampleConcentrationCode: 9},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
        {
          type: 'input',
          label: '标准曲线',
          paramName: 'curveFileNo',
          initialValue: params.data.curveFileNo,
          rules: [config.reg.required]
        },
        designFormulasHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.sampleVolumeCode)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'sampleVolumeCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '定容体积(mL)',
          dataIndex: 'constantVolume',
          key: 'constantVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('constantVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'constantVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '稀释倍数',
          dataIndex: 'dilutionRatio',
          key: 'dilutionRatio',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `进样浓度(${getUnitCodeStr(params.data.samplingConcentrationCode)})`,
          dataIndex: 'samplingConcentration',
          key: 'samplingConcentration',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="samplingConcentration">
                {[{label: 'μg/mL', value: 5},
                  {label: 'μg/L', value: 6},
                  {label: 'ng/mL', value: 7},
                  {label: 'ng/L', value: 8},
                  {label: 'mg/L', value: 9}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('samplingConcentration', false);
                      params.onTitleFilter(item.value, 'samplingConcentrationCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('samplingConcentration', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('samplingConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'samplingConcentration', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.sampleConcentrationCode)})`,
          dataIndex: 'sampleConcentration',
          key: 'sampleConcentration',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleConcentration">
                {[{label: 'mg/L', value: 9},
                  {label: 'μg/L', value: 6},
                  {label: 'mg/Kg', value: 10},
                  {label: 'μg/Kg', value: 11},
                  {label: 'mg/m³', value: 12},
                  {label: 'μg/m³', value: 13}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleConcentration', false)
                      params.onTitleFilter(item.value, 'sampleConcentrationCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleConcentration', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleConcentration', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /****
   * pH酸碱度电导率分析原始记录
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    result//测定结果单位
   *                    },
   * 传给父组件的参数:  this.props.Unit(name,value); //父组件获得更改单位
   * *********/
  pHAnalysis: (params) => {
    return {
      title: 'pH/酸碱度/电导率分析原始记录',
      outRequestParam: ['checkItemId', 'checkMethodId', 'checkMethodName', 'mdl', 'checkItemName',
        'instrument', 'pretreatmentMethods'],
      unitCode: {unitCode: 16},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '水温(℃)',
          dataIndex: 'temperature',
          key: 'temperature',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('temperature_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'temperature', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `测定结果(${getUnitCodeStr(params.data.unitCode)})`,
          dataIndex: 'result',
          key: 'result',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="result">
                {[{label: '无量纲', value: 16},
                  {label: 'μs/cm', value: 17},
                  {label: 'ms/s', value: 18}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('result', false);
                      params.onTitleFilter(item.value, 'unitCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('result', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('result_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'result', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /*****
   * 发热量分析原始记录
   * 需要传的参数  params={getFieldDecorator},
   * ********/
  calorificAnalysis: (params) => {
    return {
      title: '热值分析原始记录',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'instrument'],
      header: [
        checkNoHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        instrumentHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '取样量(g)',
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '干基高位热值(kJ/kg)',
          dataIndex: 'dryHightValue',
          key: 'dryHightValue',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dryHightValue_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dryHightValue', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '氢元素含量(%)',
          dataIndex: 'hydrogen',
          key: 'hydrogen',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('hydrogen_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'hydrogen', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '样品含水率（%）',
          dataIndex: 'waterRatio',
          key: 'waterRatio',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('waterRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'waterRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '湿基低位热值(kJ/kg)',
          dataIndex: 'wetLowValue',
          key: 'wetLowValue',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('wetLowValue_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'wetLowValue', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '湿基高位热值(kJ/kg)',
          dataIndex: 'wetHighValue',
          key: 'wetHighValue',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('wetHighValue_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'wetHighValue', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /****
   * 感官分析原始记录（一）
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    measuredValue,//测得值单位
   *                    concentration //样品浓度单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   * ***/
  sensoryAnalysis1: (params) => {
    return {
      title: '感官分析原始记录（一）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'solutionInfo', 'mdl'],
      unitCode: {resultUnit: 41, concentrationUnit: 41},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        {
          type: 'input',
          label: '标准溶液配置信息',
          paramName: 'solutionInfo',
          initialValue: params.data.solutionInfo,
          rules: [config.reg.required]
        },
        mdlHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '取样量(mL)',
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '稀释倍数',
          dataIndex: 'dilutionRatio',
          key: 'dilutionRatio',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `测得值(${getUnitCodeStr(params.data.resultUnit)})`,
          dataIndex: 'result',
          key: 'result',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="result">
                {[{label: 'NTU', value: 41},
                  {label: '度', value: 42},
                  {label: '倍', value: 43}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('result', false);
                      params.onTitleFilter(item.value, 'resultUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('result', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('result_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'result', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.concentrationUnit)})`,
          dataIndex: 'sampleConcentration',
          key: 'sampleConcentration',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleConcentration">
                {[{label: 'NTU', value: 41},
                  {label: '度', value: 42},
                  {label: '倍', value: 43}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleConcentration', false);
                      params.onTitleFilter(item.value, 'concentrationUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleConcentration', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleConcentration', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
    }
  },
  /***
   *  感官分析原始记录（二）
   *  需要传的参数  params={getFieldDecorator},
   * **/
  sensoryAnalysis2: (params) => {
    return {
      title: '感官分析原始记录（二）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'solutionInfo'],
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '臭和味',
          key: 'badSmell',
          children: [
            {
              title: '取样体积(mL)',
              dataIndex: 'sampleVolume',
              key: 'sampleVolume',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '原水样',
              key: 'previous',
              children: [
                {
                  title: '等级',
                  dataIndex: 'previousRank',
                  key: 'previousRank',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('previousRank_' + record.sampleNo, {
                            initialValue: record.previousRank ? record.previousRank : '1',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="1">1</Option>
                                <Option value="2">2</Option>
                                <Option value="3">3</Option>
                                <Option value="4">4</Option>
                                <Option value="5">5</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
                {
                  title: '强度',
                  dataIndex: 'previousIntensity',
                  key: 'previousIntensity',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('previousIntensity_' + record.sampleNo, {
                            initialValue: record.previousIntensity ? record.previousIntensity : '11',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="11">无</Option>
                                <Option value="12">微弱</Option>
                                <Option value="13">弱</Option>
                                <Option value="14">明显</Option>
                                <Option value="15">强</Option>
                                <Option value="16">很强</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
                {
                  title: '说明',
                  dataIndex: 'previousExplain',
                  key: 'previousExplain',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('previousExplain_' + record.sampleNo, {
                            initialValue: record.previousExplain ? record.previousExplain : '21',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="21">无任何气味</Option>
                                <Option value="22">一般饮用者难于察觉、嗅觉敏感者可以察觉</Option>
                                <Option value="23">一般饮用者刚能察觉</Option>
                                <Option value="24">已有明显察觉</Option>
                                <Option value="25">有很明显的臭味</Option>
                                <Option value="26">有强烈的恶臭</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
              ]
            },
            {
              title: '煮沸后',
              key: 'after',
              children: [
                {
                  title: '等级',
                  dataIndex: 'afterRank',
                  key: 'afterRank',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('afterRank_' + record.sampleNo, {
                            initialValue: record.afterRank ? record.afterRank : '1',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="1">1</Option>
                                <Option value="2">2</Option>
                                <Option value="3">3</Option>
                                <Option value="4">4</Option>
                                <Option value="5">5</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
                {
                  title: '强度',
                  dataIndex: 'afterIntensity',
                  key: 'afterIntensity',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('afterIntensity_' + record.sampleNo, {
                            initialValue: record.afterIntensity ? record.afterIntensity : '11',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="11">无</Option>
                                <Option value="12">微弱</Option>
                                <Option value="13">弱</Option>
                                <Option value="14">明显</Option>
                                <Option value="15">强</Option>
                                <Option value="16">很强</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
                {
                  title: '说明',
                  dataIndex: 'afterExplain',
                  key: 'afterExplain',
                  render: (text, record) => {
                    if (params && params.data.readOnly)
                      return (<span>{text}</span>);
                    return (
                      <FormItem key={record.key}>
                        {
                          params.getFieldDecorator('afterExplain_' + record.sampleNo, {
                            initialValue: record.afterExplain ? record.afterExplain : '21',
                            rules: [config.reg.required]
                          })(
                            (
                              <Select
                                showSearch
                              >
                                <Option value="21">无任何气味</Option>
                                <Option value="22">一般饮用者难于察觉、嗅觉敏感者可以察觉</Option>
                                <Option value="23">一般饮用者刚能察觉</Option>
                                <Option value="24">已有明显察觉</Option>
                                <Option value="25">有很明显的臭味</Option>
                                <Option value="26">有强烈的恶臭</Option>
                              </Select>
                            )
                          )
                        }
                      </FormItem>
                    );
                  }
                },
              ]
            },
          ]
        },
        {
          title: '肉眼可见物',
          dataIndex: 'seeSomthing',
          key: 'seeSomthing',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('seeSomthing_' + record.sampleNo, {
                    initialValue: record.seeSomthing ? record.seeSomthing : '31',
                    rules: [config.reg.required]
                  })(
                    (
                      <Select
                        showSearch
                      >
                        <Option value="31">无</Option>
                        <Option value="32">有</Option>
                      </Select>
                    )
                  )
                }
              </FormItem>
            );
          }
        },
      ],
      remark: commonRemark,
    }
  },
  /****
   * 固体废物含水率分析原始记录（一）
   * 需要传的参数  params={getFieldDecorator},
   * ***/
  solidRecord1: (params) => {
    return {
      title: '固体废物含水率分析原始记录（一）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument'],
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '取样量(g)',
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '容器重(g)',
          children: [
            {
              title: 'B1',
              dataIndex: 'bOne',
              key: 'bOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('bOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'bOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'B2',
              dataIndex: 'bTwo',
              key: 'bTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('bTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'bTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M1',
              dataIndex: 'mOne',
              key: 'mOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('mOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'mOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '容器+烘干样品重(g)',
          children: [
            {
              title: 'A1',
              dataIndex: 'aOne',
              key: 'aOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('aOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'aOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'A2',
              dataIndex: 'aTwo',
              key: 'aTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('aTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'aTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M2',
              dataIndex: 'mTwo',
              key: 'mTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('mTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'mTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '干固体重(g)',
          dataIndex: 'drySolidWeight',
          key: 'drySolidWeight',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('drySolidWeight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'drySolidWeight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '含水率(%)',
          dataIndex: 'waterRatio',
          key: 'waterRatio',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('waterRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'waterRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '干固体百分率(%)',
          dataIndex: 'drySolidPercentage',
          key: 'drySolidPercentage',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('drySolidPercentage_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'drySolidPercentage', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      extra: '适用范围：适用于不含有初始液相的固废样品。',
      remark: commonRemark,
    }
  },
  /****
   * 固体废物含水率分析原始记录（二）
   * 需要传的参数  params={getFieldDecorator},
   * ***/
  solidRecord2: (params) => {
    return {
      title: '固体废物含水率分析原始记录（二）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument'],
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '初始固液相总重(g)',
          dataIndex: 'solidAndLiquid',
          key: 'solidAndLiquid',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('solidAndLiquid_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'solidAndLiquid', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '初始液相重(g)',
          dataIndex: 'liquid',
          key: 'liquid',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('liquid_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'liquid', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '滤渣取样量(g)',
          dataIndex: 'residue',
          key: 'residue',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('residue_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'residue', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '容器重(g)',
          children: [
            {
              title: 'B1',
              dataIndex: 'bOne',
              key: 'bOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('bOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'bOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'B2',
              dataIndex: 'bTwo',
              key: 'bTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('bTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'bTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M1',
              dataIndex: 'mOne',
              key: 'mOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('mOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'mOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '容器+烘干样品重(g)',
          children: [
            {
              title: 'A1',
              dataIndex: 'aOne',
              key: 'aOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('aOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'aOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'A2',
              dataIndex: 'aTwo',
              key: 'aTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('aTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'aTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M2',
              dataIndex: 'mTwo',
              key: 'mTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('mTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'mTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '干固体重(g)',
          dataIndex: '8',
          key: '8',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('drySolidWeight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'drySolidWeight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '滤渣含水率(%)',
          dataIndex: 'moistureOfResidue',
          key: 'moistureOfResidue',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('moistureOfResidue_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'moistureOfResidue', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '干固体百分率(%)',
          dataIndex: 'drySolidPercentage',
          key: 'drySolidPercentage',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('drySolidPercentage_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'drySolidPercentage', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      extra: '适用范围：适用于含有初始液相的固废样品。',
      remark: commonRemark,
    }
  },
  /****
   * 离子选择电极分析原始记录
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    amount,//取样量单位
   *                    concentration //样品浓度单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   * ***/
  lonSelective: (params) => {
    return {
      title: '离子选择电极分析原始记录',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument',
        'pretreatmentMethods', 'curveFileNo', 'designFormulas'],
      unitCode: {sampleVolumeCode: 3, sampleConcentrationCode: 9},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
        {
          type: 'input',
          label: '标准曲线',
          paramName: 'curveFileNo',
          initialValue: params.data.curveFileNo,
          rules: [config.reg.required]
        },
        designFormulasHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.sampleVolumeCode)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'sampleVolumeCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '稀释倍数',
          dataIndex: 'dilutionRatio',
          key: 'dilutionRatio',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '电极电位(mV)',
          dataIndex: 'electrodePotential',
          key: 'electrodePotential',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('electrodePotential_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'electrodePotential', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '测得值(μg)',
          dataIndex: 'result',
          key: 'result',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('result_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'result', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.sampleConcentrationCode)})`,
          dataIndex: 'sampleConcentration',
          key: 'sampleConcentration',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleConcentration">
                {[{label: 'mg/L', value: 9},
                  {label: 'mg/Kg', value: 10},
                  {label: 'mg/m³', value: 12},
                  {label: 'μg/m³', value: 13},
                  {label: '%', value: 14}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleConcentration', false)
                      params.onTitleFilter(item.value, 'sampleConcentrationCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleConcentration', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleConcentration', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /***
   * 两虫分析原始记录
   *  需要传的参数  params={getFieldDecorator},
   * ***/
  insectRecord: (params) => {
    return {
      title: '两虫分析原始记录',
      outRequestParam: ['mdl', 'instrument', 'pretreatmentMethods'],
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '采样体积(L)',
          dataIndex: 'samplingVolume',
          key: 'samplingVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('samplingVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'samplingVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '计数样本中孢（卵）囊数X',
          children: [
            {
              title: '贾地鞭毛虫',
              dataIndex: 'giardiaCystsInSample',
              key: 'giardiaCystsInSample',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('giardiaCystsInSample_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input
                          onBlur={(e) => params.onChange(record.sampleNo, 'giardiaCystsInSample', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '隐孢子虫',
              dataIndex: 'cryptosporidiumInSample',
              key: 'cryptosporidiumInSample',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('cryptosporidiumInSample_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input
                          onBlur={(e) => params.onChange(record.sampleNo, 'cryptosporidiumInSample', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '每10升水中孢（卵）囊数Y',
          children: [
            {
              title: '贾地鞭毛虫',
              dataIndex: 'giardiaCysts',
              key: 'giardiaCysts',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('giardiaCysts_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'giardiaCysts', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '隐孢子虫',
              dataIndex: 'cryptosporidium',
              key: 'cryptosporidium',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('cryptosporidium_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'cryptosporidium', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
      ],
      remark: commonRemark,
    }
  },
  /****
   * 容量分析原始记录
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    amount,//取样量单位
   *                    standard,//标准液用量单位单位
   *                    concentration //样品浓度单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   * ****/
  capacityAnalysis: (params) => {
    return {
      title: '容量分析原始记录',
      outRequestParam: ['mdl', 'instrument', 'pretreatmentMethods', 'checkMethodId', 'checkMethodName',
        'checkItemId', 'checkItemName', 'designFormulas'],
      unitCode: {sampleVolumeCode: 3, fluidDosageCode: 5, sampleConcentrationCode: 9},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
        designFormulasHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.sampleVolumeCode)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'sampleVolumeCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '稀释倍数',
          dataIndex: 'dilutionRatio',
          key: 'dilutionRatio',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionRatio_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionRatio', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `标准液用量(${getUnitCodeStr(params.data.fluidDosageCode)})`,
          dataIndex: 'fluidDosage',
          key: 'fluidDosage',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="fluidDosage">
                {[{label: 'μg/mL', value: 5},
                  {label: 'μg/L', value: 6},
                  {label: 'mg/L', value: 9},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('fluidDosage', false);
                      params.onTitleFilter(item.value, 'fluidDosageCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('fluidDosage', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('fluidDosage_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'fluidDosage', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.sampleConcentrationCode)})`,
          dataIndex: 'sampleConcentration',
          key: 'sampleConcentration',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleConcentration">
                {[{label: 'mg/L', value: 9},
                  {label: 'mg/Kg', value: 10},
                  {label: 'g/Kg', value: 19},
                  {label: 'mg/m³', value: 12},
                  {label: '%', value: 14}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleConcentration', false)
                      params.onTitleFilter(item.value, 'sampleConcentrationCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleConcentration', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleConcentration_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleConcentration', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params)
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /***
   * 三点比较式臭袋法厂界环境臭气测定结果登记表
   * **/
  communityEnvironment: (params) => {
    return {
      title: '三点比较式臭袋法厂界环境臭气测定结果登记表',
      outRequestParam: [],
      header: [
        checkNoHeader(params),
        checkMethodHeader(params),
        {
          type: 'input',
          label: '嗅辨员①',
          paramName: 'no3'
        },
        {
          type: 'input',
          label: '嗅辨员②',
          paramName: 'no4'
        },
        {
          type: 'input',
          label: '嗅辨员③',
          paramName: 'no5'
        },
        {
          type: 'input',
          label: '嗅辨员④',
          paramName: 'no6'
        },
        {
          type: 'input',
          label: '嗅辨员⑤',
          paramName: 'no7'
        },
        {
          type: 'input',
          label: '嗅辨员⑥',
          paramName: 'no8'
        },
      ],
      columns: [],
      remark: '注：√正确  ×错误  △不明     M—小组平均正解率；   t1— 小组平均正解率M1时的稀释；   t2— 小组平均正解率M2时的稀释；\n' +
      '    小组平均正解率M=  a—答案正确的人次数；  b—答案不明的人次数；  c—答案为错误的人次数；  n—解答总数（18人次）;'
    }
  },
  /***
   * 三点比较式臭袋法污染源臭气测定结果登记表
   * **/
  pollutionSources: (params) => {
    return {
      title: '三点比较式臭袋法污染源臭气测定结果登记表',
      outRequestParam: [],
      header: [
        checkNoHeader(params),
        checkMethodHeader(params),
        {
          type: 'input',
          label: '嗅辨员①',
          paramName: 'no3'
        },
        {
          type: 'input',
          label: '嗅辨员②',
          paramName: 'no4'
        },
        {
          type: 'input',
          label: '嗅辨员③',
          paramName: 'no5'
        },
        {
          type: 'input',
          label: '嗅辨员④',
          paramName: 'no6'
        },
        {
          type: 'input',
          label: '嗅辨员⑤',
          paramName: 'no7'
        },
        {
          type: 'input',
          label: '嗅辨员⑥',
          paramName: 'no8'
        },
      ],
      columns: [],
      remark: ''
    }
  },
  /***
   * 微生物分析原始记录
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    result,//检测结果单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   ***/
  microbiologicalAnalysis: (params) => {
    return {
      title: '微生物分析原始记录',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName'],
      unitCode: {unitCode: 20},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        {
          type: 'input',
          label: '培养条件',
          paramName: 'trainCondition',
          initialValue: params.data.trainCondition,
          rules: [config.reg.required]
        },
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '不同稀释度的平均菌落数',
          children: [
            {
              title: '10^1',
              dataIndex: 'tenOne',
              key: 'tenOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '10^0',
              dataIndex: 'tenZero',
              key: 'tenZero',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenZero_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenZero', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '10^-1',
              dataIndex: 'tenBearOne',
              key: 'tenBearOne',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenBearOne_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenBearOne', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '10^-2',
              dataIndex: 'tenBearTwo',
              key: 'tenBearTwo',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenBearTwo_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenBearTwo', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '10^-3',
              dataIndex: 'tenBearThree',
              key: 'tenBearThree',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenBearThree_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenBearThree', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: '10^-4',
              dataIndex: 'tenBearFour',
              key: 'tenBearFour',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('tenBearFour_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'tenBearFour', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: `检测结果(${getUnitCodeStr(params.data.unitCode)})`,
          dataIndex: 'result',
          key: 'result',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="result">
                {[{label: 'MPN/L', value: 20},
                  {label: '个/mL', value: 21},
                  {label: 'MPN/100mL', value: 22},
                  {label: '个/g', value: 23},
                  {label: 'CFU/mL', value: 24}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('result', false);
                      params.onTitleFilter(item.value, 'unitCode')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('result', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, '', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params, 'memo')
      ],
      remark: commonRemark,
    }
  },
  /***
   * 仪器分析原始记录（二）
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    amount,//取样量单位
   *                    result,//测得结果单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   * ***/
  instrumentAnalysis2: (params) => {
    return {
      title: '仪器分析原始记录（二）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument', 'pretreatmentMethods'],
      unitCode: {samplingWeightUnit: 3, resultUnit: 25},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.samplingWeightUnit)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'samplingWeightUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `测得结果(${getUnitCodeStr(params.data.resultUnit)})`,
          dataIndex: 'result',
          key: 'result',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="result">
                {[{label: 'L/(kg.min)', value: 25},
                  {label: 'L/(kg.h)', value: 26},
                  {label: '℃', value: 27},
                  {label: 's', value: 28},
                  {label: 'min', value: 29}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('result', false);
                      params.onTitleFilter(item.value, 'resultUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('result', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, '', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '判定结果',
          dataIndex: 'judgeResult',
          key: 'judgeResult',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('judgeResult_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'judgeResult', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params, 'memo')
      ],
      extra: '适用范围：适用于反应性和易燃性鉴别的物质。',
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /***
   * 仪器分析原始记录（三）
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    amount,//取样量单位
   *                    samplingConcentration,//进样浓度单位
   *                    sampleConcentration,//样品浓度单位
   *                    },
   * 传给父组件的参数: this.props.Unit(name,value); //父组件获得更改单位
   * ***/
  instrumentAnalysis3: (params) => {
    return {
      title: '仪器分析原始记录（三）',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument',
        'pretreatmentMethods', 'curveNo', 'designFormulas'],
      unitCode: {unit: 3, samplingThicknessUnit: 5, sampleThicknessUnit: 9},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
        {
          type: 'input',
          label: '标准曲线',
          paramName: 'curveNo',
          initialValue: params.data.curveNo,
          rules: [config.reg.required]
        },
        designFormulasHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.unit)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'unit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '定容体积(mL)',
          dataIndex: 'constantVolume',
          key: 'constantVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('constantVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'constantVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '稀释倍数',
          dataIndex: 'dilutionMultiple',
          key: 'dilutionMultiple',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dilutionMultiple_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dilutionMultiple', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '减空白后吸光度',
          dataIndex: 'absorbance',
          key: 'absorbance',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('absorbance_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'absorbance', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `进样浓度(${getUnitCodeStr(params.data.samplingThicknessUnit)})`,
          dataIndex: 'samplingThickness',
          key: 'samplingThickness',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="samplingThickness">
                {[{label: 'μg/mL', value: 5},
                  {label: 'μg/L', value: 6},
                  {label: 'mg/L', value: 9}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('samplingThickness', false);
                      params.onTitleFilter(item.value, 'samplingThicknessUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('samplingThickness', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('samplingThickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'samplingThickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.sampleThicknessUnit)})`,
          dataIndex: 'sampleThickness',
          key: 'sampleThickness',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleThickness">
                {[{label: 'mg/L', value: 9},
                  {label: 'mg/Kg', value: 10},
                  {label: 'g/Kg', value: 19},
                  {label: 'mg/m³', value: 12},
                  {label: '%', value: 14}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleThickness', false)
                      params.onTitleFilter(item.value, 'sampleThicknessUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleThickness', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleThickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleThickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params, 'memo')
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /****
   * 职业卫生粉尘滤膜称量记录
   * 需要传的参数  params={getFieldDecorator},
   * ***/
  occupationalHealth: (params) => {
    return {
      title: '职业卫生粉尘滤膜称量记录',
      outRequestParam: ['pretreatmentMethods', 'checkMethodId', 'checkMethodName', 'formulas'],
      header: [
        checkNoHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        designFormulasHeader(params, 'formulas'),
        {
          type: 'input',
          label: '计算公式',
          paramName: 'formulas',
          initialValue: params.data.formulas,
          rules: [config.reg.required]
        },
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '采样前滤膜质量(mg)',
          dataIndex: 'membraneBefore',
          key: 'membraneBefore',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('membraneBefore_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'membraneBefore', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '采样后滤膜质量(mg)',
          dataIndex: 'membraneAfter',
          key: 'membraneAfter',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('membraneAfter_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'membraneAfter', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '滤膜增重(mg)',
          dataIndex: 'dynamiting',
          key: 'dynamiting',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('dynamiting_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'dynamiting', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '采样体积(m3)',
          dataIndex: 'samplingVolume',
          key: 'samplingVolume',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('samplingVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'samplingVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '浓度(mg/m3)',
          dataIndex: 'thickness',
          key: 'thickness',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('thickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'thickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params, 'memo')
      ],
      remark: commonRemark,
    }
  },
  /****
   * 重量分析原始记录
   * 需要传的参数  params={
   *                    getFieldDecorator,
   *                    amount,//取样量单位
   *                    concentration,//样品浓度单位
   *                    },
   * 传给父组件的参数:this.props.Unit(name,value); //父组件获得更改单位
   * **/
  weightAnalysis: (params) => {
    return {
      title: '重量分析原始记录',
      outRequestParam: ['checkMethodId', 'checkMethodName', 'checkItemId', 'checkItemName', 'mdl', 'instrument',
        'pretreatmentMethods'],
      unitCode: {unit: 3, sampleThicknessUnit: 9},
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: `取样量(${getUnitCodeStr(params.data.unit)})`,
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleVolume">
                {[{label: 'mL', value: 1},
                  {label: 'g', value: 2},
                  {label: 'L', value: 3},].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleVolume', false);
                      params.onTitleFilter(item.value, 'unit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleVolume', visible)
          },
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '容器重(g)',
          children: [
            {
              title: 'A1',
              dataIndex: 'a1',
              key: 'a1',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('a1_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'a1', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'A2',
              dataIndex: 'a2',
              key: 'a2',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('a2_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'a2', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M1',
              dataIndex: 'm1',
              key: 'm1',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('m1_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'm1', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '烘干后容器+样品重(g)',
          children: [
            {
              title: 'B1',
              dataIndex: 'b1',
              key: 'b1',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('b1_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'b1', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'B2',
              dataIndex: 'b2',
              key: 'b2',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('b2_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'b2', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M2',
              dataIndex: 'm2',
              key: 'm2',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('m2_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'm2', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '灼烧后容器+样品重(g)',
          children: [
            {
              title: 'C1',
              dataIndex: 'c1',
              key: 'c1',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('c1_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'c1', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'C2',
              dataIndex: 'c2',
              key: 'c2',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('c2_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'c2', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
            {
              title: 'M3',
              dataIndex: 'm3',
              key: 'm3',
              render: (text, record) => {
                if (params && params.data.readOnly)
                  return (<span>{text}</span>);
                return (
                  <FormItem key={record.key}>
                    {
                      params.getFieldDecorator('m3_' + record.sampleNo, {
                        initialValue: text,
                        rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                      })(
                        <Input onBlur={(e) => params.onChange(record.sampleNo, 'm3', e.target.value)}/>
                      )
                    }
                  </FormItem>
                );
              }
            },
          ]
        },
        {
          title: '样品重(g)',
          dataIndex: 'weight',
          key: 'weight',
          render: (text, record) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('weight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'weight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: `样品浓度(${getUnitCodeStr(params.data.sampleThicknessUnit)})`,
          dataIndex: 'sampleThickness',
          key: 'sampleThickness',
          filterDropdown: (
            <div>
              <ul className={style.jymUl} id="sampleThickness">
                {[{label: 'mg/L', value: 9},
                  {label: 'mg/m³', value: 12},
                  {label: '%', value: 14}].map((item, index) => (
                    <li key={index} onClick={() => {
                      hideUl('sampleThickness', false)
                      params.onTitleFilter(item.value, 'sampleThicknessUnit')
                    }}>
                      {item.label}
                    </li>
                  )
                )}
              </ul>
            </div>
          ),
          filterIcon: <Icon type="down"/>,
          onFilterDropdownVisibleChange: (visible) => {
            hideUl('sampleThickness', visible)
          },
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleThickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleThickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        remarkColumn(params, 'memo')
      ],
      remark: commonRemark,
      emptySample: commonEmptySample
    }
  },
  /****
   * 总αβ放射性测定原始记录
   * 需要传的参数  params={getFieldDecorator,}
   * ***/
  radiationMeasurement: (params) => {
    return {
      title: '总αβ放射性测定原始记录',
      outRequestParam: ['checkItemName', 'checkMethodName', 'mdl', 'instrument', 'pretreatmentMethods',
        'checkMethodId', 'checkItemId'],
      header: [
        checkNoHeader(params),
        checkItemHeader(params),
        checkMethodHeader(params),
        applianceInfoHeader(params),
        mdlHeader(params),
        instrumentHeader(params),
        pretreatmentMethodsHeader(params),
      ],
      columns: [
        numColumn(params),
        sampleColumn(params),
        {
          title: '取样体积(L)',
          dataIndex: 'sampleVolume',
          key: 'sampleVolume',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleVolume_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleVolume', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '坩埚重(g)',
          dataIndex: 'potWeight',
          key: 'potWeight',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('potWeight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'potWeight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '坩埚+样品重(g)',
          dataIndex: 'potSampleWeight',
          key: 'potSampleWeight',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('potSampleWeight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'potSampleWeight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '样品重',
          dataIndex: 'sampleWeight',
          key: 'sampleWeight',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('sampleWeight_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'sampleWeight', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: 'α计数(次)',
          dataIndex: 'acount',
          key: 'acount',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('acount_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'acount', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: 'β计数(次)',
          dataIndex: 'bcount',
          key: 'bcount',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('bcount_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'bcount', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '总α浓度(Bq/L)',
          dataIndex: 'athickness',
          key: 'athickness',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('athickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'athickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
        {
          title: '总β浓度(Bq/L)',
          dataIndex: 'bthickness',
          key: 'bthickness',
          render: (text, record, index) => {
            if (params && params.data.readOnly)
              return (<span>{text}</span>);
            return (
              <FormItem key={record.key}>
                {
                  params.getFieldDecorator('bthickness_' + record.sampleNo, {
                    initialValue: text,
                    rules: [config.reg.required, config.reg.absLong, config.reg.long2]
                  })(
                    <Input onBlur={(e) => params.onChange(record.sampleNo, 'bthickness', e.target.value)}/>
                  )
                }
              </FormItem>
            );
          }
        },
      ],
      remark: commonRemark,
    }
  },

}
